package cn.com.xy.sms.sdk.service.travel;

import java.util.Map;

import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;

import android.os.Process;
import cn.com.xy.sms.sdk.Iservice.OnlineUpdateCycleConfigInterface;
import cn.com.xy.sms.sdk.constant.Constant;
import cn.com.xy.sms.sdk.db.TrainManager;
import cn.com.xy.sms.sdk.db.entity.MatchCacheManager;
import cn.com.xy.sms.sdk.dex.DexUtil;
import cn.com.xy.sms.sdk.log.LogManager;
import cn.com.xy.sms.sdk.net.NetUtil;
import cn.com.xy.sms.sdk.net.NetWebUtil;
/* SDK-459/yangzhi/2016.05.26---end--- */
/*SDK-616 hewengao 20160918 start*/
import cn.com.xy.sms.sdk.threadpool.SmartSmsThreadPoolManager;
/* SDK-459/yangzhi/2016.05.26---start--- */
import cn.com.xy.sms.sdk.util.DateUtils;
import cn.com.xy.sms.sdk.util.JsonUtil;
import cn.com.xy.sms.sdk.util.StringUtils;
import cn.com.xy.sms.sdk.util.XyUtil;
import cn.com.xy.sms.util.SdkCallBack;
/*SDK-616 hewengao 20160918 end*/
/**
 * 旅行相关服务
 * 主要是火车，飞机相关服务
 * 火车站点列表
 * 航班动态
 * @author hewengao
 *
 */
public class TravelService {
	private static final long TRAIN_DATA_EXPIRE = 7 * 24 * 3600 * 1000;
//	public static ExecutorService mQueryTrainInfoPool = Executors.newFixedThreadPool(1);
    /**
     * 判断车次途经站信息是否符合要求
     * 
     * @param stationList
     *            车次途经站信息集合
     * @param from
     *            出发地
     * @param to
     *            目的地
     * @param isOnlineData
     *            (已弃用)是否联网查询的数据
     * @return true:符合要求 false:不符合要求
     */
    public static boolean checkStationList(String stationList, String from, String to, boolean isOnlineData) {
    	if (stationList == null) {
            return false;
        }
        try {
            JSONArray stationjsonArr = new JSONArray(stationList);
            /* SDK-726/yangzhi/2017.02.20---start--- */
            if (stationjsonArr == null || stationjsonArr.length() == 0) {
                return false;
            }
            /* SDK-726/yangzhi/2017.02.20---end--- */

            // 数据源：[{"name":"上海南","spt":"15:43","stt":"15:43"},{"name":"松江","spt":"16:01","stt":"16:05"}]
            // 只有目的地，只要目的地不为第一个站点则符合要求
            if (StringUtils.isNull(from) && !StringUtils.isNull(to)) {
                JSONObject firstStation = (JSONObject) stationjsonArr.get(0);
                if (firstStation != null && !firstStation.getString("name").trim().equalsIgnoreCase(to.trim())) {
                    return true;
                }

                // 只有出发地，只要出发地不为最后一个站点则符合要求
            } else if (StringUtils.isNull(to) && !StringUtils.isNull(from)) {
                JSONObject lastStation = (JSONObject) stationjsonArr.get(stationjsonArr.length() - 1);
                if (lastStation != null && !lastStation.getString("name").trim().equalsIgnoreCase(from.trim())) {
                    return true;
                }

                // 存在出发地与目的地，只要出发地在目的地之前则符合要求
            } else if (!StringUtils.isNull(from) && !StringUtils.isNull(to)) {
                int fromNameIndex = stationList.indexOf("\"" + from + "\"");
                int toNameIndex = stationList.indexOf("\"" + to + "\"");

                if (fromNameIndex != -1 && toNameIndex != -1 && fromNameIndex < toNameIndex) {
                    return true;
                }
           /*MEIZUIC-17 songzhirong 20160607 start*/
            }else if(StringUtils.isNull(from) && StringUtils.isNull(to)){
                return true;
            }
            /*MEIZUIC-17 songzhirong 20160607 end*/

        } catch (JSONException e) {
            // ex.printStackTrace();
            LogManager.e(Constant.TAG, "queryTrainInfo: ", e);

        }

        return false;
    }
    
    
    /**
     * 依据航班号和航班时间，获取航班到达时间
     * 
     * @param flightNum
     *            航班号
     * @param flightDate
     *            航班时间
     * @param extend
     *            扩展参数
     * @param callBack
     *            无数据或异常时返回参数为null，正常情况返回参数： index0(String):短信ID
     *            index1(JSONObject):航班信息Json对象 例: {"FlightCompany":"上海航空有限公司",
     *            "FlightDeptimePlanDate":"2014-12-01 18:30:00",
     *            "FlightArrtimePlanDate":"2014-12-01 21:05:00",
     *            "FlightHTerminal":"T2","FlightDep":"上海",
     *            "FlightArr":"广州","FlightQueryTime":1433300561019,
     *            "FlightDepAirport":"上海虹桥国际", "FlightArrAirport":"广州白云国际"}
     */
    public static void queryFlightData(final String id, String flightNum, String flightDate, Map<String, Object> extend, final SdkCallBack xyCallBack) {

        // 没有航班号或航班日期直接返回
        if (StringUtils.isNull(flightNum) || StringUtils.isNull(flightDate)) {
            XyUtil.doXycallBackResult(xyCallBack, null);
            return;
        }

        final String flight_form = (String) JsonUtil.getValueWithMap(extend, "flight_form");
        final String flight_to = (String) JsonUtil.getValueWithMap(extend, "flight_to");
        final String flight_from_airport = (String) JsonUtil.getValueWithMap(extend, "flight_from_airport");
        final String flight_to_airport = (String) JsonUtil.getValueWithMap(extend, "flight_to_airport");

        // 入库到丰富气泡数据缓存所需参数
        final String phoneNumber = (String) JsonUtil.getValueWithMap(extend, "phoneNumber");
        final String titleNo = (String) JsonUtil.getValueWithMap(extend, "titleNo");
        final String msgId = (String) JsonUtil.getValueWithMap(extend, "msgId");
        final String strBubbleJsonObj = (String) JsonUtil.getValueWithMap(extend, "bubbleJsonObj");
        final String messageBody = (String) JsonUtil.getValueWithMap(extend, "messageBody");
        final String notSaveToDb = (String) JsonUtil.getValueWithMap(extend, "notSaveToDb");
        /*  BD-209 songzhirong 2016.06.06---start--- */
        SdkCallBack callBack = new SdkCallBack() {
        /*  BD-209 songzhirong 2016.06.06---end--- */
            @Override
            public void execute(final Object... obj) {
                JSONObject returnObj = null;
                JSONObject bubbleJsonObj = null;

                if (!StringUtils.isNull(strBubbleJsonObj)) {
                    try {
                        bubbleJsonObj = new JSONObject(strBubbleJsonObj);
                    } catch (JSONException e) {
                        // ex.printStackTrace();
                        LogManager.e(Constant.TAG, "queryFlightData: ", e);

                    }
                }

                try {
                    if (obj == null || obj.length < 2 || obj[1].toString().indexOf("[") != 0) {
                        XyUtil.doXycallBackResult(xyCallBack, null);
                        return;
                    }

                    JSONArray jsonArray = new JSONArray((String) obj[1]);

                    String flightCompany = ""; // 航空公司
                    String flightDeptimePlanDate = ""; // 计划起飞时间
                    String flightArrtimePlanDate = ""; // 计划到达时间
                    String flightHTerminal = ""; // 航站楼
                    String flightDep = ""; // 起点
                    String flightArr = ""; // 终点
                    String flightDepAirport = ""; // 起飞机场
                    String flightArrAirport = ""; // 降落机场
                    /*HUAWEI-1300 zhengxiaobo 20160706 begin*/
                    String flightState = ""; // 航班状态
                    String flightTerminal = ""; // 到达航站楼
                    /*HUAWEI-1300 zhengxiaobo 20160706 end*/
                    for (int i = 0; i < jsonArray.length(); i++) {
                        JSONObject resultObject = (JSONObject) jsonArray.get(i);
                        flightCompany = resultObject.getString("FlightCompany"); // 航空公司
                        flightDeptimePlanDate = resultObject.getString("FlightDeptimePlanDate"); // 计划起飞时间
                        flightArrtimePlanDate = resultObject.getString("FlightArrtimePlanDate"); // 计划到达时间
                        flightHTerminal = resultObject.getString("FlightHTerminal"); // 航站楼
                        flightDep = resultObject.getString("FlightDep"); // 起点
                        flightArr = resultObject.getString("FlightArr"); // 终点
                        flightDepAirport = resultObject.getString("FlightDepAirport"); // 起飞机场
                        flightArrAirport = resultObject.getString("FlightArrAirport"); // 降落机场
                        /*HUAWEI-1300 zhengxiaobo 20160706 begin*/
                        flightState = resultObject.getString("FlightState"); // 航班状态
                        flightTerminal = resultObject.getString("FlightTerminal");
                        /*HUAWEI-1300 zhengxiaobo 20160706 end*/
                        // 同时没有出发地、目的地、出发机场、到达机场参数，结束循环，返回第一组接口数据
                        if (StringUtils.isNull(flight_form) && StringUtils.isNull(flight_to) && StringUtils.isNull(flight_from_airport) && StringUtils.isNull(flight_to_airport)) {
                            break;
                        }

                        // 如果出发地和目的地匹配，结束循环，返回该组接口数据
                        if (!StringUtils.isNull(flight_form) && !StringUtils.isNull(flight_to) && flight_form.indexOf(flightDep) != -1 && flight_to.indexOf(flightArr) != -1) {
                            break;
                        }

                        // 如果只有出发地并且当前接口数据存在该出发地，去除目的地数据，结束循环，返回该组接口数据
                        if (!StringUtils.isNull(flight_form) && StringUtils.isNull(flight_to) && flight_form.equals(flightDep)) {
                            flightArr = "";
                            flightArrtimePlanDate = "";
                            flightArrAirport = "";
                            break;
                        }

                        // 如果只有目的地并且当前接口数据存在该目的地，去除出发地数据，结束循环，返回该组接口数据
                        if (!StringUtils.isNull(flight_to) && StringUtils.isNull(flight_form) && flight_to.equals(flightArr)) {
                            flightDep = "";
                            flightDeptimePlanDate = "";
                            flightDepAirport = "";
                            break;
                        }

                        // 如果只有出发地机场和目的机场，没有出发地与目的地信息，并且接口数据两个机场信息都匹配，结束循环，返回该组接口数据
                        if (StringUtils.isNull(flight_form) && StringUtils.isNull(flight_to) && !StringUtils.isNull(flight_from_airport) && !StringUtils.isNull(flight_to_airport) && flightDepAirport.contains(flight_from_airport) && flightArrAirport.contains(flight_to_airport)) {
                            break;
                        }

                        // 如果只有出发地机场，没有目的地机场、出发地、目的地信息，并且接口的出发地机场信息匹配，结束循环，返回该组接口数据
                        if (StringUtils.isNull(flight_form) && StringUtils.isNull(flight_to) && StringUtils.isNull(flight_to_airport) && !StringUtils.isNull(flight_from_airport) && flightDepAirport.contains(flight_from_airport)) {
                            break;
                        }

                        // 如果只有目的地机场，没有出发地机场、出发地、目的地信息，并且接口的目的地机场信息匹配，结束循环，返回该组接口数据
                        if (StringUtils.isNull(flight_form) && StringUtils.isNull(flight_to) && StringUtils.isNull(flight_from_airport) && !StringUtils.isNull(flight_to_airport) && flightArrAirport.contains(flight_to_airport)) {
                            break;
                        }

                        // 没有匹配数据，清除航空公司名称
                        flightCompany = "";
                    }

                    // 已找到匹配数据
                    if (!StringUtils.isNull(flightCompany)) {
                        returnObj = new JSONObject();
                        returnObj.put("FlightCompany", flightCompany);
                        returnObj.put("FlightDeptimePlanDate", flightDeptimePlanDate);
                        returnObj.put("FlightArrtimePlanDate", flightArrtimePlanDate);
                        returnObj.put("FlightHTerminal", flightHTerminal);
                        returnObj.put("FlightDep", flightDep);
                        returnObj.put("FlightArr", flightArr);
                        returnObj.put("FlightQueryTime", System.currentTimeMillis());
                        returnObj.put("FlightDepAirport", flightDepAirport);
                        returnObj.put("FlightArrAirport", flightArrAirport);
                        /*HUAWEI-1300 zhengxiaobo 20160706 begin*/
                        returnObj.put("FlightState", flightState);
                        returnObj.put("FlightTerminal", flightTerminal);
                        /*HUAWEI-1300 zhengxiaobo 20160706 end*/
                        XyUtil.doXycallBackResult(xyCallBack, id, returnObj);
                        return;
                    }

                    // 没有找到匹配数据
                    XyUtil.doXycallBackResult(xyCallBack, null);
                } catch (JSONException e) {
                    // ex.printStackTrace();
                    LogManager.e(Constant.TAG, "queryFlightData: ", e);

                    XyUtil.doXycallBackResult(xyCallBack, null);
                } finally {
                    if (bubbleJsonObj == null || Boolean.TRUE.toString().equals(notSaveToDb)) {
                        return;
                    }
                    // 气泡数据缓存入库
                    try {
                        // 设置查询时间
                        bubbleJsonObj.put("QueryTime", System.currentTimeMillis());

                        if (returnObj != null) {
                            JsonUtil.JSONCombine(bubbleJsonObj, returnObj);
                        }
                        MatchCacheManager.updateMatchCacheManager(phoneNumber, titleNo, msgId, bubbleJsonObj, messageBody);
                    } catch (Exception e) {
                        // ex.printStackTrace();
                        LogManager.e(Constant.TAG, "queryFlightData: ", e);
                    }
                }
            }
        };
      /*  try {
            JSONObject jsonObject = new JSONObject();
            jsonObject.put("flight_num", flightNum.replace(" ", "")); // 去除航班号中间的空格
            jsonObject.put("flight_date", flightDate);
            NetWebUtil.sendPostRequest(NetWebUtil.WEB_SERVER_URL_FLIGHT, jsonObject.toString(), callBack);
        } catch (JSONException e) {
            // ex.printStackTrace();
            LogManager.e(Constant.TAG, "queryFlightData: " + e.getMessage(), e);

            XyUtil.doXycallBackResult(xyCallBack, null);
        }*/
        queryFlightData(flightNum, flightDate, extend, callBack);
    }
        /**
         * 执行根据车次查询本地数据库车次途经站信息，如数据库无相关车次信息则使用联网查询接口
         * 
         * @param id
         *            短信ID
         * @param trainNum
         *            车次号，多个以/隔开
         * @param from
         *            出发地
         * @param to
         *            目的地
         * @param callBack
         *            回调函数 无数据或异常时返回参数为null，正常情况返回参数： index0(String):短信ID
         *            index1(JSONObject):车次信息Json对象
         *            例:{"station_list":"[{\"name\":\"重庆北\",\"spt\":\"07:48\", \
         *            "stt\":\"07:48\"},{\"name\":\"广安\",\"spt\":\"09:13\",\"stt\":\"09:20\"}]"
         *            , "duration":"21:35"} index2(String):车次号 index3(String):出发地
         *            index4(String):目的地 index5(boolean):true=联网接口 false=本地接口
         */
            /* SDK-459/yangzhi/2016.05.26---start--- */
        private static void doQueryTrainInfo(final String id, final String trainNum, final String day, final String from, final String to, final SdkCallBack callBack, Map<String, Object> extend) {
            if (StringUtils.isNull(trainNum)) {
                XyUtil.doXycallBackResult(callBack, id, null, trainNum, from, to, false);
                return;
            }

            // 根据车次查询本地数据库车次途径站信息
            JSONObject stationInfoJsonObject = queryTrainInfo(trainNum, day, from, to);
            /* SDK-459/yangzhi/2016.05.26---end--- */
            long dataTime = 0;
            try {
                String strDateTime = (String) JsonUtil.getValueFromJsonObject(stationInfoJsonObject, "data_time");
                if (strDateTime != null) {
                    dataTime = Long.parseLong(strDateTime);
                }
            } catch (NumberFormatException ex) {

            }

            /* SDK-487 huangzhiqiang 20160707 start */
            
            boolean accessNetWork = canAccessNetWork(extend);

            // 本地数据库已查询到车次信息并且数据未过期或断网状态返回本地查询结果
            if (stationInfoJsonObject != null && (!needQueryNetTrainInfo(dataTime) || !accessNetWork)) {
            /* SDK-487 huangzhiqiang 20160707 end */
                try {
                    // 同一接口返回数据，将数据库取得的车次信息JSON字符串转换为JSONArray对象
                    String stationList = (String) JsonUtil.getValueFromJsonObject(stationInfoJsonObject, "station_list");
                    if (!StringUtils.isNull(stationList)) {
                        stationInfoJsonObject.put("station_list", new JSONArray(stationList));
                    }
                } catch (JSONException e) {
                    // ex.printStackTrace();
                    LogManager.e(Constant.TAG, "queryTrainInfo: ", e);

                }
                XyUtil.doXycallBackResult(callBack, id, stationInfoJsonObject, trainNum, from, to, false);// false:非联网查询
                return;
            }

            /* SDK-487 huangzhiqiang 20160707 start */
            // 无法联网直接返回
            if (!accessNetWork) {
            /* SDK-487 huangzhiqiang 20160707 end */
                XyUtil.doXycallBackResult(callBack, id, "offNetwork");
                return;
            }

            // 调用联网查询
            // 只有一个车次号或同时没有出发地与目的地，查询第一个车次号的信息
            /* SDK-459/yangzhi/2016.05.26---start--- */
            /* RM-1193/yangzhi/2016.01.16---start--- */
            TrainManager.checkDataOnline(callBack, id, trainNum, day, from, to, extend);
            /* RM-1193/yangzhi/2016.01.16---end--- */
            /* SDK-459/yangzhi/2016.05.26---end--- */
    }

    /* SDK-487 huangzhiqiang 20160707 start */
    private static boolean canAccessNetWork(Map<String, Object> extend) {
        boolean allNetworkState = false;
        try {
            if (extend != null && extend.containsKey("allNetworkState")) {
                allNetworkState = (Boolean) extend.get("allNetworkState");
            }
        } catch (Throwable e) {
            LogManager.e(Constant.TAG, "TravelService canAccessNetWork error:", e);
        }
        return allNetworkState ? (XyUtil.checkNetWork(Constant.getContext(), 2) == 0) : NetUtil.checkAccessNetWork(2);
    }
    /* SDK-487 huangzhiqiang 20160707 end */

    /**
     * 根据车次查询本地数据库车次途经站信息，如数据库无相关车次信息则使用联网查询接口
     * 
     * @param id
     *            短信ID
     * @param trainNum
     *            车次号
     * @param from
     *            出发地
     * @param to
     *            目的地
     * @param extend
     *            扩展参数
     * @param callBack
     *            回调函数 无数据或异常时返回参数为null，正常情况返回参数： index0(String):短信ID
     *            index1(JSONObject):车次信息Json对象
     *            例:{"station_list":"[{\"name\":\"重庆北\",\"spt\":\"07:48\", \
     *            "stt\":\"07:48\"},{\"name\":\"广安\",\"spt\":\"09:13\",\"stt\":\"09:20\"}]"
     *            } 其中name为站点名，spt为到站时间，stt为出站时间 index2(String):车次号
     *            index3(String):出发地 index4(String):目的地
     *            index5(boolean):true=联网接口 false=本地接口
     */
    public static void queryTrainInfo(final String id, final String trainNum, final String from, final String to, final Map<String, Object> extend, final SdkCallBack callBack) {
        // 入库到丰富气泡数据缓存所需参数
        final String phoneNumber = (String) JsonUtil.getValueWithMap(extend, "phoneNumber");
        final String titleNo = (String) JsonUtil.getValueWithMap(extend, "titleNo");
        final String strBubbleJsonObj = (String) JsonUtil.getValueWithMap(extend, "bubbleJsonObj");
        final String messageBody = (String) JsonUtil.getValueWithMap(extend, "messageBody");
        final String notSaveToDb = (String) JsonUtil.getValueWithMap(extend, "notSaveToDb");
        /* SDK-459/yangzhi/2016.05.26---start--- */
        String dayValue = (String) JsonUtil.getValueWithMap(extend, "day");
        if (StringUtils.isNull(dayValue)) {
            dayValue = DateUtils.getTimeString(Constant.PATTERN, System.currentTimeMillis());
        }
        final String day = dayValue;
        
        // 传入的时间超过当前时间1个月,不需要查数据库和网络查询
        if(!StringUtils.isNull(day) && !needQueryTrainInfo(day)){
            XyUtil.doXycallBackResult(callBack, id, "timeOut");
            return;
        }
        /* SDK-459/yangzhi/2016.05.26---end--- */

//       SmartSmsThreadPoolManager.mQueryTrainInfoPool;
        /*SDK-616 hewengao/20160918 start*/
        SmartSmsThreadPoolManager.netWebPool.execute(new Runnable() {
        /*SDK-616 hewengao/20160918 start*/
            @Override
            public void run() {
                try {
                    /*SDK-633 hewengao 20161009 start*/
                    SmartSmsThreadPoolManager.setThreadNameAndPriority(SmartSmsThreadPoolManager.TNAME_SERVICE_DATA_QUERY, Process.THREAD_PRIORITY_BACKGROUND);
                    /*SDK-633 hewengao 20161009 end*/
                    SdkCallBack requestCallback = new SdkCallBack() {
                        @Override
                        public void execute(Object... obj) {
                            JSONObject bubbleJsonObj = null;
                            if (!StringUtils.isNull(strBubbleJsonObj)) {
                                try {
                                    bubbleJsonObj = new JSONObject(strBubbleJsonObj);
                                } catch (JSONException e) {
                                    // ex.printStackTrace();
                                    LogManager.e(Constant.TAG, "queryTrainInfo: ", e);

                                }
                            }

                            String networkState = null;
                            // 记录网络状态
                            if (obj != null && obj.length == 2 && obj[1] != null && "offNetwork".equalsIgnoreCase(obj[1].toString())) {
                                networkState = "offNetwork";
                            }
                            try {
                                if (obj == null || obj.length != 6 || obj[0] == null || obj[1] == null) {
                                    // 无查询结果，返回当前网络状态，用于判断是否因为断网导致无法联网查询数据
                                    XyUtil.doXycallBackResult(callBack, networkState);
                                    return;
                                }

                                // 是否联网查询的数据 true:联网查询数据 false:本地数据库数据
                                boolean isOnlineData = (Boolean) obj[5];
                                if (isOnlineData) {
                                    String stationList = JsonUtil.getValueFromJsonObject((JSONObject) obj[1], "station_list").toString();
                                    String from = (String) obj[3];
                                    String to = (String) obj[4];

                                    // 联网查询数据且车次途经站信息不符合要求
                                    if (!checkStationList(stationList, from, to, true)) {
                                        bubbleJsonObj = null;
                                        XyUtil.doXycallBackResult(callBack, null);
                                        return;
                                    }
                                }
                                XyUtil.doXycallBackResult(callBack, obj[0], obj[1], obj[2], obj[3], obj[4], obj[5]);
                            }
                            finally {
                                if (bubbleJsonObj == null || Boolean.TRUE.toString().equals(notSaveToDb)) {
                                    return;
                                }
                                // 气泡数据缓存入库
                                try {
                                    // 设置查询时间
                                    bubbleJsonObj.put("QueryTime", System.currentTimeMillis());
                                    // 记录或清除断网状态记录
                                    bubbleJsonObj.put("networkState", networkState);
                                    String stationList = null;
                                    if (obj != null && obj.length > 1) {
                                        stationList = JsonUtil.getValueFromJsonObject((JSONObject) obj[1], "station_list").toString();
                                    }
                                    if (!StringUtils.isNull(stationList)) {
                                        bubbleJsonObj.put("station_list", stationList);
                                    }
                                    if (obj != null && obj.length > 0) {
                                        MatchCacheManager.updateMatchCacheManager(phoneNumber, titleNo, (String) obj[0], bubbleJsonObj, messageBody);
                                    }
                                }
                                catch (JSONException e) {
                                    // ex.printStackTrace();
                                    LogManager.e(Constant.TAG, "queryTrainInfo: ", e);
                                }
                            }
                        }
                    };
                    /* SDK-459/yangzhi/2016.05.26---start--- */
                    doQueryTrainInfo(id, trainNum, day, from, to, requestCallback, extend);
                    /* SDK-459/yangzhi/2016.05.26---end--- */

                } catch (Throwable e) {
                    LogManager.e(Constant.TAG, e.getMessage(), e);
                }
            }
        });
    }

   

    /**
     * 查询本地数据库车次途径站信息
     * 
     * @param allTrainNum
     *            包含所有车次号的字符串，车次号以/隔开
     * @param from
     *            出发地
     * @param to
     *            目的地
     * @return 车次车站信息
     */
    /* SDK-459/yangzhi/2016.05.26---start--- */
    private static JSONObject queryTrainInfo(String allTrainNum, String day, String from, String to) {
        if (StringUtils.isNull(allTrainNum)) {
            return null;
        }
        String[] trainNumArr = allTrainNum.split("/");
        // 只有一个车次号或同时没有出发地与目的地，直接返回第一个车次号的数据
        if (trainNumArr.length == 1 || (StringUtils.isNull(from) && StringUtils.isNull(to))) {
            return TrainManager.queryTrainInfo(trainNumArr[0], day);
        }

        JSONObject stationInfoJsonObject = null;
        String stationList = null;
        for (String train : trainNumArr) {
            stationInfoJsonObject = TrainManager.queryTrainInfo(train, day);
    /* SDK-459/yangzhi/2016.05.26---end--- */
            stationList = (String) JsonUtil.getValueFromJsonObject(stationInfoJsonObject, "station_list");
            if (StringUtils.isNull(stationList)) {
                continue;
            }

            if (checkStationList(stationList, from, to, false)) {
                return stationInfoJsonObject;
            }
        }

        return null;
    }

    /**
     * 需要联网查询车次数据，数据时间超过指定时间则需要重新查询
     * 
     * @param dateTime
     *            数据时间
     * @return true:需要联网查询车次数据 false:不需要
     */
    private static boolean needQueryNetTrainInfo(long dateTime) {
        return System.currentTimeMillis() - dateTime > DexUtil.getUpdateCycleByType(OnlineUpdateCycleConfigInterface.TYPE_TRAIN_DATA_VALID_CYCLE, TRAIN_DATA_EXPIRE);
    }
    /* SDK-459/yangzhi/2016.05.26---start--- */
    /**
     * 需要查数据库和网络查询车次数据，数据时间超过指定时间则需要重新查询
     * 
     * @param dateTime
     *            数据时间
     * @return true:需要联网查询车次数据 false:不需要
     */
    private static boolean needQueryTrainInfo(String day) {
        long dateTime = DateUtils.getTime(day, Constant.PATTERN);
        return System.currentTimeMillis() - dateTime < DexUtil.getUpdateCycleByType(OnlineUpdateCycleConfigInterface.TYPE_TRAIN_DATA_QUERY_CYCLE, Constant.month);
    }
    /* SDK-459/yangzhi/2016.05.26---end--- */
    /*  BD-209 songzhirong 2016.06.06---start--- */

    /**
     * 依据航班号和航班时间，获取航班到达时间
     * 
     * @param flightNum
     *            航班号
     * @param flightDate
     *            航班时间
     * @param extend
     *            扩展参数
     * @param callBack
     *            无数据或异常时返回参数为null，正常情况返回参数： index0(String):短信ID
     *            index1(JSONObject):航班信息Json对象 例:
     *            [{"fcategory":"0","FlightNo":"MU5720"
     *            ,"FlightCompany":"中国东方航空股份有限公司"
     *            ,"FlightDepcode":"PEK","FlightArrcode"
     *            :"KMG","FlightDeptimePlanDate"
     *            :"2016-04-11 21:55:00","FlightArrtimePlanDate"
     *            :"2016-04-12 01:25:00"
     *            ,"FlightDeptimeDate":"2016-04-11 22:08:00"
     *            ,"FlightArrtimeDate":
     *            "2016-04-12 01:27:00","BoardGate":"33","FlightState"
     *            :"到达","FlightHTerminal"
     *            :"T2","FlightTerminal":"","org_timezone"
     *            :"28800","dst_timezone"
     *            :"28800","FlightDep":"北京","FlightArr":"昆明"
     *            ,"FlightDepAirport":"北京首都","FlightArrAirport":"昆明长水"}]
     */
    public static void queryFlightData(String flightNum, String flightDate,
            Map<String, Object> extend, final SdkCallBack xyCallBack) {
        try {
            JSONObject jsonObject = new JSONObject();
            jsonObject.put("flight_num", flightNum.replace(" ", "")); // 去除航班号中间的空格
            jsonObject.put("flight_date", flightDate);
            NetWebUtil.sendPostRequest(NetWebUtil.WEB_SERVER_URL_FLIGHT,
                    jsonObject.toString(), xyCallBack);
        } catch (JSONException e) {
            // ex.printStackTrace();
            LogManager.e(Constant.TAG, "queryFlightData: ", e);

            XyUtil.doXycallBackResult(xyCallBack, null);
        }
    }
    /*  BD-209 songzhirong 2016.06.06---end--- */

}
